package com.xuwang.service.impl;

import com.xuwang.Util.JWTutil;
import com.xuwang.mapper.AdditiveMapper;
import com.xuwang.pojo.Inventory;
import com.xuwang.mapper.InventoryMapper;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;

/**
 * 库存表(Inventory)表服务实现类
 *
 * @author abaaba
 * @since 2021-09-18 09:10:59
 * @version 1.0
 */
@Service("inventoryService")
public class InventoryServiceImpl {
    @Resource
    private InventoryMapper inventoryMapper;
    @Resource
    private AdditiveMapper additiveMapper;
//
//    /**
//     * 根据模糊条件查询总个数
//     *
//     * @param name 查询条件
//     * @return 返回查询到的总个数
//     */
//    public Map<String, Object> selectForCount(String name) {
//        Map<String, Object> map = new HashMap<>();
//        // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
//        map.put("code", 200);
//        map.put("msg", "查询成功");
//        map.put("data", this.inventoryMapper.selectForCount(name));
//        return map;
//    }

    /**
     * 直接从别人库存进货的时候，查看其他企业的库存，根据名字返回批号，货物名、库存量、对应库存企业。
     * @return  返回所有数据
     */
    public Map<String, Object> selectAllByName(String name) {
        Map<String, Object> map = new HashMap<>();
        // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("code", 200);
        map.put("msg", "查询成功");
        map.put("data", this.inventoryMapper.selectAllByName(name));
        return map;
    }
    public Map<String, Object> selectBatchByMyCompany(int m,HttpServletRequest request) {
        String token = request.getHeader("Authorization");
        String userName = JWTutil.getUserName(token);
//        String userName="菜品人";
        int companyId = additiveMapper.selectCompanyIdByUsername(userName);
        Map<String, Object> map = new HashMap<>();
        // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("code", 200);
        map.put("msg", "查询成功");
        if (m==1) {
            map.put("data", this.inventoryMapper.selectBatchByMyCompany( companyId));

        }else {
            map.put("data", this.inventoryMapper.selectBatchAllByMyCompany( companyId));
        }
        return map;
    }


    public Map<String, Object> selectProductionCompanyByName(String name) {
        Map<String, Object> map = new HashMap<>();
        // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("code", 200);
        map.put("msg", "查询成功");
        map.put("data", this.inventoryMapper.selectProductionCompanyByName(name));
        return map;
    }
    public Map<String, Object> selectProductionAllByName(String name,HttpServletRequest request) {
        String token = request.getHeader("Authorization");
        String userName = JWTutil.getUserName(token);
//        String userName="添加剂人";
        int companyId = additiveMapper.selectCompanyIdByUsername(userName);
        Map<String, Object> map = new HashMap<>();
        // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("code", 200);
        map.put("msg", "查询成功");
        map.put("data", this.inventoryMapper.selectProductionAllByName(name,companyId));
        return map;
    }


    /**
     * 通过ID查询单条数据
     *
     * @param id 主键
     * @return 实例对象
     */
    public Map<String, Object> selectById(Integer id) {

        Integer type = inventoryMapper.selectTypeById(id);
        Map<String, Object> map = new HashMap<>();
        // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("code", 200);
        map.put("msg", "查询成功");
        map.put("data", this.inventoryMapper.selectById(id,type));
        return map;
    }

    /**
     * 查询分页数据
     *
     * @param index 查询起始位置
     * @param name  查询条件
     * @return 对象列表
     */
    public Map<String, Object> selectForPageZF(int index,int page, Integer type, String batchNo, String name, String companyName
                                             ) {
    // 获取当前表中的总记录
        int tableCount = this.inventoryMapper.selectForCount(type,batchNo,name,companyName);
        // 总页码计算   (总条数 - 1) / 每页显示条数  + 1
        // (100 - 1) / 10 + 1 = 10        (101 - 1) / 10 + 1 = 11      (99 - 1) / 10 + 1 = 10
        int pageCount = (tableCount - 1) / page + 1;
        // 计算每页开始的下标值
        index = (index - 1) * page;
        Map<String, Object> map = new HashMap<>();
        map.put("code", 0);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("msg", "查询成功");
        map.put("pageCount", pageCount);  // 查询的记录总页码
        map.put("count", tableCount);     // 当前表中的总条数
        map.put("data", this.inventoryMapper.selectForPage(index, page,type,batchNo,name,companyName));
        return map;
    }
    /**
     * 查询分页数据
     *
     * @param index 查询起始位置
     * @param name  查询条件
     * @return 对象列表
     */
    public Map<String, Object> selectForPageQY(int index,int page, Integer type, String batchNo, String name,
                                               HttpServletRequest request ) {
        // 获取当前表中的总记录
        String token = request.getHeader("Authorization");
        String userName = JWTutil.getUserName(token);
        //生产类型需要查询！！！！！！
//        String userName=null;
////        if (type==1){
////            userName="原料人";
////        }else if (type==2){
//            userName="添加剂人";
////        }else if (type==3){
////            userName="菜品人";
////        }
        // 获取当前表中的总记录
        int tableCount = this.inventoryMapper.selectForCount(type,batchNo,name,additiveMapper.selectCompanyNameByUsername(userName));
        // 总页码计算   (总条数 - 1) / 每页显示条数  + 1
        // (100 - 1) / 10 + 1 = 10        (101 - 1) / 10 + 1 = 11      (99 - 1) / 10 + 1 = 10
        int pageCount = (tableCount - 1) / 10 + 1;
        // 计算每页开始的下标值
        index = (index - 1) * 10;
        Map<String, Object> map = new HashMap<>();
        map.put("code", 0);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("msg", "查询成功");
        map.put("pageCount", pageCount);  // 查询的记录总页码
        map.put("count", tableCount);     // 当前表中的总条数
        map.put("data", this.inventoryMapper.selectForPage(index, page,type,batchNo,name, additiveMapper.selectCompanyNameByUsername(userName)));
        return map;
    }

    /**
     * 新增数据
     *
     * @param inventory 实例对象
     * @return 实例对象
     */
    public Map<String, Object> insert(Inventory inventory) {
        // UUID.randomUUID()  返回内容：asd21321-ewrewrew213213-123213zsad-123asdasd这样的形态
//        this.inventoryMapper.insert(inventory);
        Map<String, Object> map = new HashMap<>();
        map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("msg", "新增成功");
        return map;
    }

    /**
     * 通过ID查询单条数据
     *
     * @param inventory 实例对象
     * @return 实例对象
     */
    public Map<String, Object> updateById(Inventory inventory) {
        this.inventoryMapper.updateById(inventory);
        Map<String, Object> map = new HashMap<>();
        map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("msg", "更新成功");
        return map;
    }

    /**
     * 通过主键删除数据
     *
     * @param id 主键
     * @return 是否成功
     */
    public Map<String, Object> deleteById(String id) {
        this.inventoryMapper.deleteById(id);
        Map<String, Object> map = new HashMap<>();
        map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("msg", "删除成功");
        return map;
    }
}